import { ElMessage, ElNotification } from 'element-plus';

/**
 * 全局错误处理工具
 * 提供统一的错误处理方式，并支持错误日志记录
 */
export default class ErrorHandler {
  
  // 定义错误类型
  static ERROR_TYPES = {
    NETWORK: 'network',    // 网络请求错误
    API: 'api',            // API响应错误
    AUTH: 'auth',          // 认证相关错误
    VALIDATION: 'validation', // 数据验证错误
    UNKNOWN: 'unknown'     // 未知错误
  };
  
  /**
   * 处理错误
   * @param {Error} error - 错误对象
   * @param {string} type - 错误类型 
   * @param {Object} options - 配置选项
   * @returns {void}
   */
  static handleError(error, type = ErrorHandler.ERROR_TYPES.UNKNOWN, options = {}) {
    // 提取错误信息
    const errorMessage = this.extractErrorMessage(error, type);
    
    // 记录错误到控制台
    this.logError(error, type, errorMessage);
    
    // 根据错误类型显示不同的提示
    this.showUserFeedback(errorMessage, type, options);
    
    // 如果需要，可以上报错误到监控系统
    // this.reportError(error, type, errorMessage);
    
    return errorMessage;
  }
  
  /**
   * 从错误对象中提取错误信息
   */
  static extractErrorMessage(error, type) {
    if (!error) return '发生未知错误';
    
    // 处理不同类型的错误
    switch (type) {
      case this.ERROR_TYPES.NETWORK:
        if (error.response) {
          // 服务器返回非2xx响应
          return `请求失败 (${error.response.status}): ${error.response.data.message || '服务器错误'}`;
        } else if (error.request) {
          // 请求发出但没有收到响应
          return '网络请求失败，请检查网络连接';
        } else {
          // 请求配置错误
          return '请求配置错误: ' + error.message;
        }
        
      case this.ERROR_TYPES.API:
        // 处理API错误
        if (error.data && error.data.code) {
          return `操作失败 (${error.data.code}): ${error.data.msg || error.data.message || '未知错误'}`;
        }
        return error.message || '接口调用失败';
        
      case this.ERROR_TYPES.AUTH:
        return error.message || '认证失败，请重新登录';
        
      case this.ERROR_TYPES.VALIDATION:
        return error.message || '数据验证失败，请检查输入';
        
      default:
        return error.message || '发生未知错误';
    }
  }
  
  /**
   * 记录错误到控制台
   */
  static logError(error, type, message) {
    console.group(`错误[${type}]: ${message}`);
    console.error(error);
    
    // 记录额外上下文
    if (error.response) {
      console.log('Response:', error.response);
    }
    if (error.request) {
      console.log('Request:', error.request);
    }
    if (error.config) {
      console.log('Config:', error.config);
    }
    
    console.groupEnd();
  }
  
  /**
   * 向用户显示错误反馈
   */
  static showUserFeedback(message, type, options = {}) {
    const { showNotification = false, duration = 3000 } = options;
    
    // 特定类型的错误使用通知，其他使用消息提示
    if (showNotification || type === this.ERROR_TYPES.AUTH) {
      ElNotification({
        title: this.getErrorTitle(type),
        message,
        type: 'error',
        duration: duration
      });
    } else {
      ElMessage({
        message,
        type: 'error',
        duration: duration,
        showClose: true
      });
    }
  }
  
  /**
   * 获取错误类型对应的标题
   */
  static getErrorTitle(type) {
    switch (type) {
      case this.ERROR_TYPES.NETWORK: return '网络错误';
      case this.ERROR_TYPES.API: return '接口错误';
      case this.ERROR_TYPES.AUTH: return '认证错误';
      case this.ERROR_TYPES.VALIDATION: return '验证错误';
      default: return '系统错误';
    }
  }
  
  /**
   * HTTP请求错误处理
   */
  static handleHttpError(error) {
    // 处理Axios错误
    return this.handleError(error, this.ERROR_TYPES.NETWORK);
  }
  
  /**
   * API响应错误处理
   */
  static handleApiError(response) {
    return this.handleError(response, this.ERROR_TYPES.API);
  }
  
  /**
   * 认证错误处理
   */
  static handleAuthError(error) {
    return this.handleError(error, this.ERROR_TYPES.AUTH, { showNotification: true });
  }
  
  /**
   * 数据验证错误
   */
  static handleValidationError(error) {
    return this.handleError(error, this.ERROR_TYPES.VALIDATION);
  }
} 